package basic

import (
	"fmt"
	"strings"
)

/*
你有50枚金币，需要分配给以下几个人：Matthew,Sarah,Augustus,Heidi,Emilie,Peter,Giana,Adriano,Aaron,Elizabeth。
分配规则如下：
a. 名字中每包含1个'e'或'E'分1枚金币
b. 名字中每包含1个'i'或'I'分2枚金币
c. 名字中每包含1个'o'或'O'分3枚金币
d: 名字中每包含1个'u'或'U'分4枚金币
写一个程序，计算每个用户分到多少金币，以及最后剩余多少金币？
程序结构如下，请实现 ‘dispatchCoin’ 函数
*/
var (
	coins = 50
	users = []string{
		"Matthew", "Sarah", "Augustus", "Heidi", "Emilie", "Peter", "Giana", "Adriano", "Aaron", "Elizabeth",
	}
	distribution = make(map[string]int, len(users))
)

func dispatchCoin() int {
	for _, user := range users {
		arr := strings.Split(user, "")
		for _, v := range arr {
			switch v {
			case "e", "E":
				distribution[user] += 1
				coins -= 1
				break
			case "i", "I":
				distribution[user] += 2
				coins -= 2
				break
			case "o", "O":
				distribution[user] += 3
				coins -= 3
				break
			case "u", "U":
				distribution[user] += 4
				coins -= 4
				break
			}
		}
	}
	return coins
}

func Func() {
	//闭包
	//闭包指的是一个函数和与其相关的引用环境组合而成的实体。简单来说，闭包=函数+引用环境。
	//f := add()
	//fmt.Print(f(10))
	//fmt.Print(f(10))
	fmt.Print(f1())
	fmt.Print(f2())
	fmt.Print(f3())
	fmt.Print(f4())

	//x := 1
	//y := 2
	//defer calc("AA", x, calc("A", x, y))
	//x = 10
	//defer calc("BB", x, calc("B", x, y))
	//y = 20
	//
	//defer func() {
	//	err := recover()
	//	if err != nil {
	//		fmt.Print(err)
	//	}
	//}()
	//FuncB()

	//left := dispatchCoin()
	//fmt.Print(distribution)
	//fmt.Println("剩下：", left)
}

func FuncB() {
	panic("报错误异常")
}

func calc(index string, a, b int) int {
	ret := a + b
	fmt.Println(index, a, b, ret)
	return ret
}

func f1() int {
	x := 5
	defer func() {
		x++
	}()
	return x
}

func f2() (x int) {
	defer func() {
		x++
	}()
	return 5
}

func f3() (y int) {
	x := 5
	defer func() {
		x++
	}()
	return x
}
func f4() (x int) {
	defer func(x int) {
		x++
	}(x)
	return 5
}

func add() func(y int) int {
	var x int
	return func(y int) int {
		x += y
		return x
	}
}
